/*
 * @author Javier A. Ramírez M.
 * jaramirez85@yahoo.es
 */
package com.jav;

import com.jav.bean.Producto;
import com.jav.bean.Proveedor;
import com.jav.data.InvMovilData;
import com.jav.per.PersisSetup;
import com.jav.per.Persistencia;
import com.sun.lwuit.util.Resources;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.file.FileConnection;
import javax.microedition.rms.RecordEnumeration;

public class Datos {

    private Hashtable proveedores;
    private Hashtable productos;
    private Vector prodOrd = null;
    private String[] CAMPOSPROVEEDORES = new String[]{"CODIGO", "NOMBRE"};
    private final String[] CAMPOSPRODUCTOS = new String[]{"CODIGO", "DESCRIPCION", "IVA", "PRECIO", "PROVEEDOR", "PACAS", "ORDEN"};
    private StringBuffer logs = new StringBuffer();
    private Resources res = null;
    private static Datos _instance;

    private Datos() {
    }

    public static Datos getInstance() {
        if (_instance == null) {
            _instance = new Datos();
        }
        return _instance;
    }

    public void carProductos(final String url) throws Exception {
        FileConnection conn = null;
        DataInputStream input = null;
        if (!isVacioPro()) {
            setProdOrd(null);
        }
        try {
            conn = (FileConnection) Connector.open(url, Connector.READ);
            input = conn.openDataInputStream();
            int ch;
            String prod = "";
            productos = new Hashtable();
            while ((ch = input.read()) != -1) {
                char c = (char) ch;
                //si no es comilla
                if (c != InvMovilData.COMILLA_ASCCI) {
                    prod += c;
                }
                if (ch == InvMovilData.ENTER_ASCCI) {
                    Producto ob_pro = new Producto();
                    //System.out.println("Leyendo: "+prod.trim());
                    Hashtable ht = splitProducto(prod.trim() + InvMovilData.PATRON);
                    if (ht == null) {
                        prod = "";
                        continue;
                    }
                    String codigo = (String) ht.get(CAMPOSPRODUCTOS[0]);
                    ob_pro.setCodigo(codigo);
                    ob_pro.setDescripcion((String) ht.get(CAMPOSPRODUCTOS[1]));
                    ob_pro.setIva(Float.parseFloat((String) ht.get(CAMPOSPRODUCTOS[2])));
                    ob_pro.setPrecio(Float.parseFloat((String) ht.get(CAMPOSPRODUCTOS[3])));
                    ob_pro.setProveedor(Integer.parseInt((String) ht.get(CAMPOSPRODUCTOS[4])));
                    ob_pro.setPacas(Integer.parseInt((String) ht.get(CAMPOSPRODUCTOS[5])));
                    ob_pro.setOrden(Integer.parseInt((String) ht.get(CAMPOSPRODUCTOS[6])));
                    prod = "";
                    productos.put(codigo.toUpperCase(), ob_pro);
                }

            }
            ordenarProductos();
            setProductos(null);

        } finally {
            try {
                if (conn != null) {
                    conn.close();
                }
                if (input != null) {
                    input.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public void carProveedor(final String url) throws Exception {
        FileConnection conn = null;
        DataInputStream input = null;
        if (!isVacioProveedor()) {
            proveedores.clear();
        }
        try {
            conn = (FileConnection) Connector.open(url, Connector.READ);
            input = conn.openDataInputStream();
            int ch;
            String prov = "";
            proveedores = new Hashtable();
            while ((ch = input.read()) != -1) {
                char c = (char) ch;
                //si no es comilla
                if (c != InvMovilData.COMILLA_ASCCI) {
                    prov += c;
                }
                if (ch == InvMovilData.ENTER_ASCCI) {
                    Proveedor ob_pro = new Proveedor();
                    Hashtable ht = splitProveedor(prov.trim() + InvMovilData.PATRON);
                    if (ht == null) {
                        prov = "";
                        continue;
                    }
                    String codigo = (String) ht.get(CAMPOSPROVEEDORES[0]);
                    ob_pro.setCodigo(codigo);
                    ob_pro.setDescripcion((String) ht.get(CAMPOSPROVEEDORES[1]));
                    prov = "";
                    proveedores.put(codigo.toUpperCase(), ob_pro);
                }

            }
        } finally {
            try {
                if (conn != null) {
                    conn.close();
                }
                if (input != null) {
                    input.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    public Hashtable splitProducto(String cadena) {
        Hashtable items = new Hashtable();
        int pos = cadena.indexOf(InvMovilData.PATRON);
        int i = 0;
        while (pos >= 0 && i < InvMovilData.NUM_COL_PRODUCTO) {
            String sub = cadena.substring(0, pos).trim();
            items.put(CAMPOSPRODUCTOS[i], sub);
            cadena = cadena.substring(pos + InvMovilData.PATRON.length());
            pos = cadena.indexOf(InvMovilData.PATRON);
            i++;
        }
        if (items.isEmpty()) {
            return null;
        }

        return items;
    }

    public Hashtable splitProveedor(String cadena) {
        Hashtable items = new Hashtable();
        int pos = cadena.indexOf(InvMovilData.PATRON);
        int i = 0;
        while (pos >= 0 && i < InvMovilData.NUM_COL_PROVE) {
            String sub = cadena.substring(0, pos).trim();
            items.put(CAMPOSPROVEEDORES[i], sub);
            cadena = cadena.substring(pos + InvMovilData.PATRON.length());
            pos = cadena.indexOf(InvMovilData.PATRON);
            i++;
        }
        if (items.isEmpty()) {
            return null;
        }

        return items;
    }

    public void ordenarProductos() {

        Vector prodOrd2 = new Vector();
        if (getProductos() != null) {

            Enumeration e = getProductos().elements();


            while (e.hasMoreElements()) {
                Producto p = ((Producto) e.nextElement());
                prodOrd2.addElement(p);
            }
        } else {
            prodOrd2 = getProdOrd();
        }


        if (prodOrd2.size() > 0) {
            PersisSetup per = getPersisSetup();
            if (per != null) {
                int orden = per.getOrdenProductos();
                //si es cero se ordena por codigo producto
                if (orden == 0) {
                    ordenarVectorXnumero(prodOrd2, 0);
                } //si es uno se ordena por descripcion
                else if (orden == 1) {
                    ordenarVectorXcadena(prodOrd2);
                } //por dos se deja como llega en el archivo
                else if (orden == 2) {
                    ordenarVectorXnumero(prodOrd2, 2);
                }
            }
        }
    }

    public void ordenarVectorXcadena(Vector vec) {

        Vector ordenado = new Vector();
        for (int count = 0; count < vec.size(); count++) {
            Producto p1 = (Producto) vec.elementAt(count);
            String cadena1 = p1.getDescripcion();

            int i = 0;
            for (i = 0; i < ordenado.size(); i++) {
                Producto p2 = (Producto) ordenado.elementAt(i);
                String cadena2 = p2.getDescripcion();
                int c = cadena1.compareTo(cadena2);
                if (c < 0) {
                    ordenado.insertElementAt(p1, i);
                    break;
                } else if (c == 0) {
                    break;
                }
            }
            if (i >= ordenado.size()) {
                ordenado.addElement(vec.elementAt(i));
            }
        }
        setProdOrd(ordenado);
    }

    public void ordenarVectorXnumero(Vector vec, int flag) {

        Producto[] arrPro = new Producto[vec.size()];
        vec.copyInto(arrPro);
        int hastai = vec.size();
        int hastaj = hastai - 1;
        for (int i = 0; i < hastai; i++) {
            for (int j = 0; j < hastaj; j++) {
                int k = 0;
                int l = 0;
                if (flag == 2) {
                    k = arrPro[j].getOrden();
                    l = arrPro[j + 1].getOrden();
                } //Pro defecto ordena por codigo
                else {
                    k = Integer.parseInt(arrPro[j].getCodigo());
                    l = Integer.parseInt(arrPro[j + 1].getCodigo());
                }

                if (k >= l) {
                    Producto aux = arrPro[j];
                    arrPro[j] = arrPro[j + 1];
                    arrPro[j + 1] = aux;
                }
            }
        }

        vec.removeAllElements();
        for (int i = 0; i < arrPro.length; i++) {
            vec.addElement(arrPro[i]);
        }

        setProdOrd(vec);

    }

    public String getPatch() {
        Persistencia p = null;
        String resp = "";
        try {
            p = new Persistencia(InvMovilData.PERS_RUTA);
            RecordEnumeration re = p.getRecordStore().enumerateRecords(null, null, false);
            while (re.hasNextElement()) {
                ByteArrayInputStream bin = new ByteArrayInputStream(re.nextRecord());
                DataInputStream din = new DataInputStream(bin);
                resp = din.readUTF();
                bin.close();
                din.close();

            }

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (p != null) {
                try {
                    p.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return resp;
    }

    public void savePatch(String ruta) throws IOException {
        Persistencia p = null;

        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(bout);
        try {
            dout.writeUTF(ruta);
            dout.flush();

            p = new Persistencia(InvMovilData.PERS_RUTA);
            p.save(bout.toByteArray());

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (dout != null) {
                dout.close();
            }
            if (bout != null) {
                bout.close();
            }
        }


    }

    public PersisSetup getPersisSetup() {
        Persistencia p = null;
        PersisSetup setup = null;
        try {
            p = new Persistencia(InvMovilData.PERS_CONFIG);
            RecordEnumeration re = p.getRecordStore().enumerateRecords(null, null, false);
            while (re.hasNextElement()) {
                setup = new PersisSetup();
                setup.resurrect(re.nextRecord());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (p != null) {
                try {
                    p.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return setup;

    }

    public Resources getRes() {
        if (res == null) {
            try {
                res = Resources.open("/res/r.res");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return res;
    }

    public StringBuffer getLogs() {
        return logs;
    }

    public void addLogs(String log) {
        String mns = "********\n" + log + "\n********\n";
        this.logs.insert(0, mns);
    }

    public Vector getProdOrd() {
        return prodOrd;
    }

    public void setProdOrd(Vector prodOrd) {
        this.prodOrd = prodOrd;
    }

    private Hashtable getProductos() {
        return productos;
    }

    private void setProductos(Hashtable productos) {
        this.productos = productos;
    }

    public boolean isVacioPro() {

        if (getProdOrd() == null) {
            return true;
        } else if (getProdOrd().isEmpty()) {
            return true;
        } else {
            return false;
        }
    }

    public Hashtable getProveedores() {
        return proveedores;
    }

    public void setProveedores(Hashtable proveedores) {
        this.proveedores = proveedores;
    }

    public boolean isVacioProveedor() {

        if (getProveedores() == null) {
            return true;
        } else {
            return false;
        }
    }

    public Producto getProductoXid(String id) {
        Producto producto = null;

        if (getProdOrd() != null) {
            producto = new Producto();
            producto.setCodigo(id);
            int index = getProdOrd().indexOf(producto);
            if (index >= 0) {
                producto = (Producto) getProdOrd().elementAt(index);
            }
        }
        return producto;
    }

    public String getDescripcionProveedorXid(String id) {
        //Si no existe el proveedor, envia id
        String descrip = id;
        if (getProveedores() != null) {
            Proveedor p = (Proveedor) getProveedores().get(id);
            if (p != null) {
                descrip = p.getDescripcion();
            }
        }

        return descrip;
    }

    public int getMaxPedido() {
        Persistencia p = null;
        int resp = 0;
        try {
            p = new Persistencia(InvMovilData.PERS_MAXCONSEC);
            RecordEnumeration re = p.getRecordStore().enumerateRecords(null, null, false);
            while (re.hasNextElement()) {
                ByteArrayInputStream bin = new ByteArrayInputStream(re.nextRecord());
                DataInputStream din = new DataInputStream(bin);
                int i = din.readInt();
                bin.close();
                din.close();
                if (i >= resp) {
                    resp = i;
                }
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (p != null) {
                try {
                    p.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        return resp + 1;
    }

    public void setMaxPedido(int num) throws IOException {
        Persistencia p = null;

        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(bout);
        try {
            dout.writeInt(num);
            dout.flush();
            Persistencia.delete(InvMovilData.PERS_MAXCONSEC);
            p = new Persistencia(InvMovilData.PERS_MAXCONSEC);
            p.save(bout.toByteArray());

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (dout != null) {
                dout.close();
            }
            if (bout != null) {
                bout.close();
            }
        }


    }
}
